Reference documentation for deal.II version 10.0.0-pre
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
Functions | Variables
include/deal.II-translator/fe/fe_0.txt File Reference

Functions

for uncommon there is then often a member function derived classes can overload that describes whether a particular feature is implemented An example is whether an element implements the information necessary to use it in the[2.x.8] finite element context (see[2.x.9] "hp-finite element support"). **[1.x.2] *Finite element classes have to define a large number of different properties describing a finite element space. The following subsections describe some nomenclature that will be used in the documentation below. *[1.x.3] *[2.x.10] "Vector-valued finite element" are elements used for systems of partial differential equations. Oftentimes
 
for uncommon there is then often a member function derived classes can overload that describes whether a particular feature is implemented An example is whether an element implements the information necessary to use it in the[2.x.8] finite element they are composed via the FESystem class which is itself derived from the current class but there are also non composed elements that have multiple components (for example the FE_Nedelec and FE_RaviartThomas classes, among others). For any of these vector valued elements
 
it is possible that some of them are in turn constrained leading to longer chains of constraints that the AffineConstraints class will eventually have to sort out (The constraints described above are used by the[2.x.62] function that constructs an AffineConstraints object.) However
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its prolongation matrices for isotropic children The return value also indicates whether a call to the[2.x.177] function will generate an error or not This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird and for which we simply need to exclude certain tests in case something is not implemented It will in general probably not be a great help in since there is not much one can do if one needs these features and they are not implemented This function could be used to check whether a call to< ttget_prolongation_matrix ()</tt > will succeed
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its restriction matrices The return value also indicates whether a call to the get_restriction_matrix () function will generate an error or not. Note
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its restriction matrices The return value also indicates whether a call to the that this function returns[2.x.178] only if the restriction matrices of the isotropic and all anisotropic refinement cases are implemented If you are interested in the restriction matrices for isotropic refinement use the isotropic_restriction_is_implemented () function instead. This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird elements
 
one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do not (yet) implement hanging node const raints. If this is the case
 
one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an since no useful return value can be generated If you should have a way to live with then you might want to use the constraints_are_implemented () function to check up front whether this function will succeed or generate the exception. *[0.x.37] *Return whether this element implements its hanging node const raints. The return value also indicates whether a call to the const raints() function will generate an error or not. This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird elements
 
one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an since no useful return value can be generated If you should have a way to live with then you might want to use the and for which we simply need to exclude certain tests in case hanging node constraints are not implemented It will in general probably not be a great help in since there is not much one can do if one needs hanging node constraints and they are not implemented This function could be used to check whether a call to< ttconstraints ()</tt > will succeed
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the get_face_interpolation_matrix () method and the get_subface_interpolation_matrix() method will generate an error or not. Currently the main purpose of this function is to allow the make_hanging_node_constraints method to decide whether the new procedures
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of n_dofs_per_vertex () of the two finite elements. The first index of each pair denotes one of the vertex dofs of the present element
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as hp_vertex_dof_indices ()
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison operator.The implementation in the current class checks for equality of the following pieces of information between the current object and the one given as argument, in this order:********- the dynamic type (i.e., the type of the most derived class) of the current object and of the given object
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by get_name ()
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This operator specifically does not check the following member variables of the current class:************- restriction matrices, ************- prolongation matrices of this object and the argument. This is because these member variables may be initialized only on demand by derived classes, rather than being available immediately. Consequently, comparing these members would not only be costly because these are generally big arrays, but also because their computation may be expensive. On the other hand, derived classes for which these arrays may differ for two objects even though the above list compares as equal, will probably want to implement their own operator== () anyway. *[0.x.49] *Non-equality comparison operator.Defined in terms of the equality comparison operator.*[0.x.50] *[2.x.191] Index computations[2.x.192] *[0.x.51] *Compute vector component and index of this shape function within the shape functions corresponding to this component from the index of a shape function within this finite element. If the element is scalar
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of other (base) elements
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are primitive (i.e. are non-zero in only one component)
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one component (i.e. the second number of the respective entry of this array) does not indicate the index of the respective shape function within the base element(since that has more than one vector-component). For this information
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the system_to_component_index () function. *[0.x.53] *Same as system_to_component_index()
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on faces (quads) have to be permuted in order to be combined with the correct shape functions. Given a local dof[2.x.197] on a quad
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the is_primitive () function in the FiniteElement class takes a cell index
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being[2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one[2.x.214] entry Elements for which this is true are called non primitive (see[2.x.215]). *[0.x.58] *Return in how many vector components the[2.x.216] shape function is non- zero. This value equals the number of entries equal to[2.x.217] in the result of the get_nonzero_components() function. For most finite element spaces
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being[2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one[2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free **Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common the result is cached and returned by this function **Return whether the[2.x.218] shape function is primitive in the sense that the shape function is non zero in only one vector component Non primitive shape functions would for be those of divergence free ansatz in which the individual vector components are coupled The result of the function is[2.x.219] if and only if the result of< ttn_nonzero_components (i)</tt > is equal to one. *[0.x.61] *Number of base elements in a mixed discretization. Note that even for vector valued finite elements
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update flags (or a subset of these flags) in[2.x.378] so they know at the time when[2.x.379] is called what they are supposed to compute[2.x.380] mapping A reference to the mapping used for computing values and derivatives of shape functions.[2.x.381] quadrature A reference to the object that describes where the shape functions should be evaluated.[2.x.382] output_data A reference to the object that FEValues will use in conjunction with the object returned here and where an implementation of[2.x.383] will place the requested information. This allows the current function to already pre-compute pieces of information that can be computed on the reference cell
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Like get_data ()
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of[2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Use the version taking a[2.x.395] argument **Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of[2.x.396] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.404] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Compute information about the shape functions on the cell denoted by the first argument Derived classes will have to implement this function based on the kind of element they represent It is called by[2.x.405] this function evaluates shape functions and their derivatives at the quadrature points represented by the mapped locations of those described by the quadrature argument to this function In many computing derivatives of shape functions (and in some cases also computing values of shape functions) requires making use of the mapping from the reference to the real cell
 
this information can either be taken from the[2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the[2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the[2.x.408] field of the object passed to this function These flags are typically set by[2.x.409][2.x.410] and (or, more specifically, implementations of these functions in derived classes). An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.412] documentation module.[2.x.413] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to.[2.x.414] cell_similarity Whether or not the cell given as first argument is simply a translation
 
this information can either be taken from the[2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the[2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the[2.x.408] field of the object passed to this function These flags are typically set by[2.x.409][2.x.410] etc of the cell for which this function was called the most recent time This information is computed simply by matching the vertices (as stored by the Triangulation) between the previous and the current cell. The value passed here may be modified by implementations of this function and should then be returned(see the discussion of the return value of this function).[2.x.415] quadrature A reference to the quadrature formula in use for the current evaluation. This quadrature object is the same as the one used when creating the[2.x.416] object. The current object is then responsible for evaluating shape functions at the mapped locations of the quadrature points represented by this object.[2.x.417] mapping A reference to the mapping object used to map from the reference cell to the current cell. This object was used to compute the information in the[2.x.418] object before the current function was called. It is also the mapping object that created the[2.x.419] mapping_internal object via[2.x.420] You will need the reference to this mapping object most often to call[2.x.421] to transform gradients and higher derivatives from the reference to the current cell.[2.x.422] mapping_internal An object specific to the mapping object. What the mapping chooses to store in there is of no relevance to the current function
 

Variables

for uncommon functions
 
for uncommon there is then often a member function derived classes can overload that describes whether a particular feature is implemented An example is whether an element implements the information necessary to use it in the[2.x.8] finite element they are composed via the FESystem class which is itself derived from the current class but there are also non composed elements that have multiple individual shape functions may be nonzero in one or several[2.x.11] components of the vector valued function If the element is[2.x.12] primitive
 
it is possible that some of them are in turn constrained themselves
 
it is possible that some of them are in turn constrained leading to longer chains of constraints that the AffineConstraints class will eventually have to sort this is of no concern for the FiniteElement and derived classes since they only act locally on one cell and its immediate neighbor
 
it is possible that some of them are in turn constrained leading to longer chains of constraints that the AffineConstraints class will eventually have to sort this is of no concern for the FiniteElement and derived classes since they only act locally on one cell and its immediate and do not see the bigger picture The[2.x.63] details how such chains are handled in practice ***Construction of a finite element and computation of the matrices described above is often a tedious task
 
 however
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its prolongation matrices for isotropic children The return value also indicates whether a call to the[2.x.177] function will generate an error or not This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird elements
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its prolongation matrices for isotropic children The return value also indicates whether a call to the[2.x.177] function will generate an error or not This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird and for which we simply need to exclude certain tests in case something is not implemented It will in general probably not be a great help in applications
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its restriction matrices The return value also indicates whether a call to the that this function returns[2.x.178] only if the restriction matrices of the isotropic and all anisotropic refinement cases are implemented If you are interested in the restriction matrices for isotropic refinement only
 
one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an exception
 
one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an since no useful return value can be generated If you should have a way to live with this
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new way
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That means
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be used
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is complete
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face interpolation
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] * If
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a vertex
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are active
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical values
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are equivalent
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way around
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither dominates
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For example
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if codim ==0` then this function compares which element dominates at the cell level. If `codim==1`
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at faces
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i e
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of domination
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in FiniteElementData
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can differ
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these cases
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always zero
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero component
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information However
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is scalar
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation in
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the index
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_orientation
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a face
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the concept
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem element
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive Unfortunately
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be flipped
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be oriented
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is true
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other hand
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were a [2.x.210]
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector components
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or quad
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a line
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for permutation
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element spaces
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being[2.x.213] since for most spaces the individual vector components are independent In that case
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being[2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence free
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being[2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one[2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free **Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common operation
 
one then still needs to cope with the lack of information this just expresses **Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns *[2.x.179] *Return the matrix interpolating from the given finite element to the present one The size of the matrix is then **Functions to support hp *[2.x.181] *Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then< tt > source **Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then< tt > source **Functions to support hp *[2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of[2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element **Same as except that the function treats degrees of freedom on lines **Same as except that the function treats degrees of freedom on quads **Return whether this element dominates another one given as argument[2.x.185] whether it is the other way whether neither or if either could dominate The[2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see[2.x.187] and in particular the[2.x.188] hp paper **Comparison ********the name returned by ********as all of the fields in ********constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns[2.x.189] For these derived classes should overload this function *This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the **Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore **For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown **Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc[2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face[2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and[2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See[2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See[2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See[2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell *This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a[2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent **For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof[2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned **Return in which of the vector components of this finite element the[2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being[2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one[2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free **Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common the result is cached and returned by this function **Return whether the[2.x.218] shape function is primitive in the sense that the shape function is non zero in only one vector component Non primitive shape functions would then
 
 consequently
 
we cannot already compute the gradients on a concrete cell at the time the current function is called
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference cell
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not compute
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e g
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these flags
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre computed
 
we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the[2.x.376] documentation module See also the documentation of the InternalDataBase class[2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of[2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Use the version taking a[2.x.395] argument **Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of[2.x.396] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together[2.x.404] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary **Compute information about the shape functions on the cell denoted by the first argument Derived classes will have to implement this function based on the kind of element they represent It is called by[2.x.405] Conceptually
 
this information can either be taken from the[2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the[2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the[2.x.408] field of the object passed to this function These flags are typically set by[2.x.409][2.x.410] rotation
 
this information can either be taken from the[2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the[2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the[2.x.408] field of the object passed to this function These flags are typically set by[2.x.409][2.x.410] etc of the cell for which this function was called the most recent time This information is computed simply by matching the but you may have to pass a reference to this object to certain functions of the Mapping class e::g[2.x.423] if you need to call them from the current function[2.x.424] mapping_data The output object into which the[2.x.425] function wrote the mapping information corresponding to the current cell This includes
 
this information can either be taken from the[2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the[2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the[2.x.408] field of the object passed to this function These flags are typically set by[2.x.409][2.x.410] etc of the cell for which this function was called the most recent time This information is computed simply by matching the but you may have to pass a reference to this object to certain functions of the Mapping class e::g[2.x.423] if you need to call them from the current function[2.x.424] mapping_data The output object into which the[2.x.425] function wrote the mapping information corresponding to the current cell This for Jacobians of the mapping that may be of relevance to the current function
 
which ones need to be filled is determined by the update flags stored inside the[2.x.430] object *FEValues ensures that this function is always called with the same pair of[2.x.432] and[2.x.433] objects In other words
 
which ones need to be filled is determined by the update flags stored inside the[2.x.430] object *FEValues ensures that this function is always called with the same pair of[2.x.432] and[2.x.433] objects In other if an implementation of this function knows that it has written a piece of data into the output argument in a previous call
 
which ones need to be filled is determined by the update flags stored inside the[2.x.430] object *FEValues ensures that this function is always called with the same pair of[2.x.432] and[2.x.433] objects In other if an implementation of this function knows that it has written a piece of data into the output argument in a previous then there is no need to copy it there again in a later call if the implementation knows that this is the same value **This function is the equivalent to[2.x.434] but for faces of cells See there for an extensive discussion of its purpose It is called by[2.x.435][2.x.436] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to[2.x.437] face_no The number of the face we are currently considering
 
which ones need to be filled is determined by the update flags stored inside the[2.x.453] object **Use the version taking a[2.x.455] argument **This function is the equivalent to[2.x.456] but for the children of faces of cells See there for an extensive discussion of its purpose It is called by[2.x.457][2.x.458] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to[2.x.459] face_no The number of the face we are currently indexed among the faces of the cell specified by the previous argument[2.x.460] sub_no The number of the subface
 

Function Documentation

◆ context()

for uncommon there is then often a member function derived classes can overload that describes whether a particular feature is implemented An example is whether an element implements the information necessary to use it in the [2.x.8] finite element context ( see "hp-finite element support"  [2.x.9])

◆ components()

for uncommon there is then often a member function derived classes can overload that describes whether a particular feature is implemented An example is whether an element implements the information necessary to use it in the [2.x.8] finite element they are composed via the FESystem class which is itself derived from the current class but there are also non composed elements that have multiple components ( for example the FE_Nedelec and FE_RaviartThomas  classes,
among  others 
)

◆ out()

it is possible that some of them are in turn constrained leading to longer chains of constraints that the AffineConstraints class will eventually have to sort out ( The constraints described above are used by the function that constructs an AffineConstraints  object.[2.x.62])

◆ get_prolongation_matrix()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its prolongation matrices for isotropic children The return value also indicates whether a call to the [2.x.177] function will generate an error or not This function is mostly here in order to allow us to write more efficient test programs which we run on all kinds of weird and for which we simply need to exclude certain tests in case something is not implemented It will in general probably not be a great help in since there is not much one can do if one needs these features and they are not implemented This function could be used to check whether a call to<tt> get_prolongation_matrix ( )

◆ get_restriction_matrix()

one then still needs to cope with the lack of information this just expresses **Return whether this element implements its restriction matrices for isotropic children The return value also indicates whether a call to the and for which we simply need to exclude certain tests in case something is not implemented It will in general probably not be a great help in since there is not much one can do if one needs these features and they are not implemented This function could be used to check whether a call to< tt > get_restriction_matrix ( )

◆ isotropic_restriction_is_implemented()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its restriction matrices The return value also indicates whether a call to the that this function returns [2.x.178] only if the restriction matrices of the isotropic and all anisotropic refinement cases are implemented If you are interested in the restriction matrices for isotropic refinement use the isotropic_restriction_is_implemented ( )

◆ not()

one then still needs to cope with the lack of information this just expresses* * Access the* * Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do not ( yet  ) const

◆ constraints_are_implemented()

one then still needs to cope with the lack of information this just expresses* * Access the* * Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an since no useful return value can be generated If you should have a way to live with then you might want to use the constraints_are_implemented ( ) const

◆ constraints()

one then still needs to cope with the lack of information this just expresses* * Access the* * Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an since no useful return value can be generated If you should have a way to live with then you might want to use the and for which we simply need to exclude certain tests in case hanging node constraints are not implemented It will in general probably not be a great help in since there is not much one can do if one needs hanging node constraints and they are not implemented This function could be used to check whether a call to<tt> constraints ( )

Definition at line 20 of file constraints_0.txt.

◆ get_face_interpolation_matrix()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the get_face_interpolation_matrix ( )
new

◆ n_dofs_per_vertex()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of n_dofs_per_vertex ( )

◆ hp_vertex_dof_indices()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as hp_vertex_dof_indices ( )

◆ operator.The implementation in the current class checks for equality of the following pieces of information between the current object and the one given as argument, in this order:********- the dynamic type()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison operator.The implementation in the current class checks for equality of the following pieces of information between the current object and the one given as argument, in this order:********- the dynamic type ( i.  e.,
the type of the most derived  class 
)

◆ get_name()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by get_name ( )

◆ operator specifically does not check the following member variables of the current class:************- restriction matrices, ************- prolongation matrices of this object and the argument. This is because these member variables may be initialized only on demand by derived classes, rather than being available immediately. Consequently, comparing these members would not only be costly because these are generally big arrays, but also because their computation may be expensive. On the other hand, derived classes for which these arrays may differ for two objects even though the above list compares as equal, will probably want to implement their own operator==()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This operator specifically does not check the following member variables of the current class:************- restriction matrices, ************- prolongation matrices of this object and the argument. This is because these member variables may be initialized only on demand by derived classes, rather than being available immediately. Consequently, comparing these members would not only be costly because these are generally big arrays, but also because their computation may be expensive. On the other hand, derived classes for which these arrays may differ for two objects even though the above list compares as equal, will probably want to implement their own operator== ( )

◆ other()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of other ( base  )

◆ primitive() [1/2]

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are primitive ( i.e. are non-zero in only one  component)

◆ component()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one component ( i.e. the second number of the respective entry of this  array)

◆ system_to_component_index()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the system_to_component_index ( )

◆ faces()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on faces ( quads  )

◆ is_primitive()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the is_primitive ( )

◆ primitive() [2/2]

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non primitive ( see  [2.x.215])

◆ n_nonzero_components()

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free* * Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common the result is cached and returned by this function* * Return whether the [2.x.218] shape function is primitive in the sense that the shape function is non zero in only one vector component Non primitive shape functions would for be those of divergence free ansatz in which the individual vector components are coupled The result of the function is [2.x.219] if and only if the result of<tt> n_nonzero_components ( i  )

◆ flags()

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update flags ( or a subset of these  flags)

◆ get_data()

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Like get_data ( )

◆ functions()

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of [2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Use the version taking a [2.x.395] argument* * Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of [2.x.396] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.404] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Compute information about the shape functions on the cell denoted by the first argument Derived classes will have to implement this function based on the kind of element they represent It is called by [2.x.405] this function evaluates shape functions and their derivatives at the quadrature points represented by the mapped locations of those described by the quadrature argument to this function In many computing derivatives of shape functions ( and in some cases also computing values of shape  functions)

◆ and()

this information can either be taken from the [2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the [2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the [2.x.408] field of the object passed to this function These flags are typically set by [2.x.409][2.x.410] and ( or  ,
more  specifically,
implementations of these functions in derived  classes 
)

◆ vertices()

this information can either be taken from the [2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the [2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the [2.x.408] field of the object passed to this function These flags are typically set by [2.x.409][2.x.410] etc of the cell for which this function was called the most recent time This information is computed simply by matching the vertices ( as stored by the  Triangulation)

Variable Documentation

◆ functions

for uncommon functions

Definition at line 2 of file fe_0.txt.

◆ primitive

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free* * Return whether the entire finite element is primitive

Definition at line 55 of file fe_0.txt.

◆ themselves

it is possible that some of them are in turn constrained themselves

Definition at line 123 of file fe_0.txt.

◆ neighbor

it is possible that some of them are in turn constrained leading to longer chains of constraints that the AffineConstraints class will eventually have to sort this is of no concern for the FiniteElement and derived classes since they only act locally on one cell and its immediate neighbor

Definition at line 123 of file fe_0.txt.

◆ task

it is possible that some of them are in turn constrained leading to longer chains of constraints that the AffineConstraints class will eventually have to sort this is of no concern for the FiniteElement and derived classes since they only act locally on one cell and its immediate and do not see the bigger picture The [2.x.63] details how such chains are handled in practice* * * Construction of a finite element and computation of the matrices described above is often a tedious task

Definition at line 127 of file fe_0.txt.

◆ however

however

Definition at line 248 of file fe_0.txt.

◆ elements

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free* * Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common the result is cached and returned by this function* * Return whether the [2.x.218] shape function is primitive in the sense that the shape function is non zero in only one vector component Non primitive shape functions would for be those of divergence free ansatz in which the individual vector components are coupled The result of the function is [2.x.219] if and only if the result of<tt> the number of components needs not coincide with the number of base elements

Definition at line 250 of file fe_0.txt.

◆ applications

one then still needs to cope with the lack of information this just expresses **Access the **Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an since no useful return value can be generated If you should have a way to live with then you might want to use the and for which we simply need to exclude certain tests in case hanging node constraints are not implemented It will in general probably not be a great help in applications

Definition at line 250 of file fe_0.txt.

◆ only

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its restriction matrices The return value also indicates whether a call to the that this function returns [2.x.178] only if the restriction matrices of the isotropic and all anisotropic refinement cases are implemented If you are interested in the restriction matrices for isotropic refinement only

Definition at line 252 of file fe_0.txt.

◆ exception

one then still needs to cope with the lack of information this just expresses* * Access the* * Return a read only reference to the matrix that describes the constraints at the interface between a refined and an unrefined cell Some finite elements do then this function will generate an exception

Definition at line 258 of file fe_0.txt.

◆ this

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like this

Definition at line 258 of file fe_0.txt.

◆ way

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new way

Definition at line 262 of file fe_0.txt.

◆ means

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That means

Definition at line 262 of file fe_0.txt.

◆ used

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be used

Definition at line 262 of file fe_0.txt.

◆ complete

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is complete

Definition at line 262 of file fe_0.txt.

◆ interpolation

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face interpolation

Definition at line 262 of file fe_0.txt.

◆ If

this iterator serves for comparisons of iterators with past the end or before the beginning states **Return an iterator which is the first iterator not on the given level If

Definition at line 274 of file fe_0.txt.

◆ vertex

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a vertex

Definition at line 274 of file fe_0.txt.

◆ active

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are active

Definition at line 274 of file fe_0.txt.

◆ values

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical values

Definition at line 274 of file fe_0.txt.

◆ equivalent

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are equivalent

Definition at line 274 of file fe_0.txt.

◆ around

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way around

Definition at line 280 of file fe_0.txt.

◆ dominates

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither dominates

Definition at line 280 of file fe_0.txt.

◆ example

which ones need to be filled is determined by the update flags stored inside the [2.x.453] object* * Use the version taking a [2.x.455] argument* * This function is the equivalent to [2.x.456] but for the children of faces of cells See there for an extensive discussion of its purpose It is called by [2.x.457][2.x.458] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to [2.x.459] face_no The number of the face we are currently indexed among the faces of the cell specified by the previous argument [2.x.460] sub_no The number of the i the number of the child of a that we are currently indexed among the children of the face specified by the previous argument [2.x.461] quadrature A reference to the quadrature formula in use for the current evaluation This quadrature object is the same as the one used when creating the [2.x.462] object The current object is then responsible for evaluating shape functions at the mapped locations of the quadrature points represented by this object [2.x.463] mapping A reference to the mapping object used to map from the reference cell to the current cell This object was used to compute the information in the [2.x.464] object before the current function was called It is also the mapping object that created the [2.x.465] mapping_internal object via [2.x.466] You will need the reference to this mapping object most often to call [2.x.467] to transform gradients and higher derivatives from the reference to the current cell [2.x.468] mapping_internal An object specific to the mapping object What the mapping chooses to store in there is of no relevance to the current but you may have to pass a reference to this object to certain functions of the Mapping class e::g [2.x.469] if you need to call them from the current function [2.x.470] mapping_data The output object into which the [2.x.471] function wrote the mapping information corresponding to the current cell This for example

Definition at line 280 of file fe_0.txt.

◆ codim

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if codim ==0` then this function compares which element dominates at the cell level. If `codim==1`

Definition at line 280 of file fe_0.txt.

◆ faces

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at faces

Definition at line 280 of file fe_0.txt.

◆ e

which ones need to be filled is determined by the update flags stored inside the [2.x.453] object* * Use the version taking a [2.x.455] argument* * This function is the equivalent to [2.x.456] but for the children of faces of cells See there for an extensive discussion of its purpose It is called by [2.x.457][2.x.458] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to [2.x.459] face_no The number of the face we are currently indexed among the faces of the cell specified by the previous argument [2.x.460] sub_no The number of the i e

Definition at line 280 of file fe_0.txt.

◆ domination

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of domination

Definition at line 280 of file fe_0.txt.

◆ FiniteElementData

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in FiniteElementData

Definition at line 315 of file fe_0.txt.

◆ differ

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can differ

Definition at line 326 of file fe_0.txt.

◆ cases

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of [2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Use the version taking a [2.x.395] argument* * Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of [2.x.396] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.404] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Compute information about the shape functions on the cell denoted by the first argument Derived classes will have to implement this function based on the kind of element they represent It is called by [2.x.405] this function evaluates shape functions and their derivatives at the quadrature points represented by the mapped locations of those described by the quadrature argument to this function In many cases

Definition at line 326 of file fe_0.txt.

◆ zero

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be zero

Definition at line 367 of file fe_0.txt.

◆ component

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector component

Definition at line 367 of file fe_0.txt.

◆ However

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information However

Definition at line 367 of file fe_0.txt.

◆ scalar

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free* * Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is scalar

Definition at line 369 of file fe_0.txt.

◆ in

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation in

Definition at line 373 of file fe_0.txt.

◆ index

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the index

Definition at line 373 of file fe_0.txt.

◆ face_orientation

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_orientation

Definition at line 373 of file fe_0.txt.

◆ face

which ones need to be filled is determined by the update flags stored inside the [2.x.453] object* * Use the version taking a [2.x.455] argument* * This function is the equivalent to [2.x.456] but for the children of faces of cells See there for an extensive discussion of its purpose It is called by [2.x.457][2.x.458] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to [2.x.459] face_no The number of the face we are currently indexed among the faces of the cell specified by the previous argument [2.x.460] sub_no The number of the i the number of the child of a face

Definition at line 373 of file fe_0.txt.

◆ concept

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the concept

Definition at line 375 of file fe_0.txt.

◆ element

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem element

Definition at line 375 of file fe_0.txt.

◆ Unfortunately

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive Unfortunately

Definition at line 375 of file fe_0.txt.

◆ flipped

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be flipped

Definition at line 377 of file fe_0.txt.

◆ oriented

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be oriented

Definition at line 377 of file fe_0.txt.

◆ true

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is true

Definition at line 378 of file fe_0.txt.

◆ hand

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other hand

Definition at line 378 of file fe_0.txt.

◆ a

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were a[2.x.210]

Definition at line 378 of file fe_0.txt.

◆ components

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual components

Definition at line 378 of file fe_0.txt.

◆ quad

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or quad

Definition at line 378 of file fe_0.txt.

◆ line

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a line

Definition at line 380 of file fe_0.txt.

◆ permutation

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for permutation

Definition at line 380 of file fe_0.txt.

◆ spaces

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free* * Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common the result is cached and returned by this function* * Return whether the [2.x.218] shape function is primitive in the sense that the shape function is non zero in only one vector component Non primitive shape functions would for be those of divergence free ansatz spaces

Definition at line 382 of file fe_0.txt.

◆ case

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that case

Definition at line 382 of file fe_0.txt.

◆ free

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence free

Definition at line 382 of file fe_0.txt.

◆ operation

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free* * Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common operation

Definition at line 386 of file fe_0.txt.

◆ then

one then still needs to cope with the lack of information this just expresses* * Return whether this element implements its hanging node constraints in the new which has to be used to make elements hp compatible That the element properly implements the get_face_interpolation_matrix and get_subface_interpolation_matrix methods Therefore the return value also indicates whether a call to the which are supposed to work in the hp framework can be or if the old well verified but not hp capable functions should be used Once the transition to the new scheme for computing the interface constraints is this function will be superfluous and will probably go away Derived classes should implement this function accordingly The default assumption is that a finite element does not provide hp capable face and the default implementation therefore returns* [2.x.179] * Return the matrix interpolating from the given finite element to the present one The size of the matrix is then* * Functions to support hp* [2.x.181] * Return the matrix interpolating from a face of one element to the face of the neighboring element The size of the matrix is then<tt> source* * Return the matrix interpolating from a face of one element to the subface of the neighboring element The size of the matrix is then<tt> source* * Functions to support hp* [2.x.183] on a several finite elements are the hp code first assigns the degrees of freedom of each of these FEs different global indices It then calls this function to find out which of them should get identical and consequently can receive the same global DoF index This function therefore returns a list of identities between DoFs of the present finite element object with the DoFs of [2.x.184] which is a reference to a finite element object representing one of the other finite elements active on this particular vertex The function computes which of the degrees of freedom of the two finite element objects are both numbered between zero and the corresponding value of whereas the second is the corresponding index of the other finite element* * Same as except that the function treats degrees of freedom on lines* * Same as except that the function treats degrees of freedom on quads* * Return whether this element dominates another one given as argument [2.x.185] whether it is the other way whether neither or if either could dominate The [2.x.186] parameter describes the codimension of the investigated subspace and specifies that it is subject to this comparison For if then the elements are compared at i the comparison happens between the function spaces of the two finite elements as restricted to a face Larger values of codim work correspondingly For a definition of see [2.x.187] and in particular the [2.x.188] hp paper* * Comparison * * * * * * * * the name returned by * * * * * * * * as all of the fields in * * * * * * * * constraint matrices This covers most cases where elements can but there are cases of derived elements that are different and for which the current function still returns [2.x.189] For these derived classes should overload this function* This then the component is always and the index within this component is equal to the overall index If the shape function referenced has more than one non zero then it cannot be associated with one vector and an exception of type ExcShapeFunctionNotPrimitive will be raised Note that if the element is composed of and a base element has more than one component but all its shape functions are then this mapping contains valid information the index of a shape function of this element within one refer to the* * Compute the shape function for the given vector component and index If the element is then the component must be and the index within this component is equal to the overall index This is the opposite operation from the but do it for shape functions and their indices on a face The range of allowed indices is therefore* * For faces with non standard face_orientation the dofs on return the if the face has non standard face_flip or face_rotation In and there is no need for permutation and consequently an exception is thrown* * Given an index in the natural ordering of indices on a return the index of the same degree of freedom on the cell To explain the consider the case where we would like to know whether a degree of freedom on a for example as part of an FESystem is primitive the so we would need to find the cell index of the shape function that corresponds to the present face index This function does that Code implementing this would then look like or can be etc [2.x.198] face_dof_index The index of the degree of freedom on a face This index must be between zero and dofs_per_face [2.x.199] face The number of the face this degree of freedom lives on This number must be between zero and [2.x.200][2.x.201] face_orientation One part of the description of the orientation of the face See [2.x.202][2.x.203] face_flip One part of the description of the orientation of the face See [2.x.204][2.x.205] face_rotation One part of the description of the orientation of the face See [2.x.206][2.x.207] The index of this degree of freedom within the set of degrees of freedom on the entire cell The returned value will be between zero and dofs_per_cell* This function exists in this class because that is where it was first implemented However it can t really work in the most general case without knowing what element we have The reason is that when a face is flipped or rotated we also need to know whether we need to swap the degrees of freedom on this face or whether they are immune from this For this consider the situation of a [2.x.209] element in If face_flip is then we need to consider the two degrees of freedom on the edge in reverse order On the other if the element were then because the two degrees of freedom on this edge belong to different vector they should not be considered in reverse order What all of this shows is that the function can t work if there are more than one degree of freedom per line or and that in these cases the function will throw an exception pointing out that this functionality will need to be provided by a derived class that knows what degrees of freedom actually represent* * For lines with non standard line_orientation the dofs on lines have to be permuted in order to be combined with the correct shape functions Given a dof [2.x.211] on a return the if the line has non standard line_orientation In and there is no need for so the given index is simply returned* * Return in which of the vector components of this finite element the [2.x.212] ith shape function is non zero The length of the returned array is equal to the number of vector components of this element For most finite element the result of this function will be a vector with exactly one element being [2.x.213] since for most spaces the individual vector components are independent In that the component with the single zero is also the first element of what for example to make a shape function divergence will there be more than one [2.x.214] entry Elements for which this is true are called non the result will be equal to one It is not equal to one only for those ansatz spaces for which vector valued shape functions couple the individual for example in order to make them divergence free* * Return whether the entire finite element is in the sense that all its shape functions are primitive If the finite element is then this is always the case Since this is an extremely common the result is cached and returned by this function* * Return whether the [2.x.218] shape function is primitive in the sense that the shape function is non zero in only one vector component Non primitive shape functions would then

Definition at line 388 of file fe_0.txt.

◆ consequently

consequently

Definition at line 547 of file fe_0.txt.

◆ called

this information can either be taken from the [2.x.406] object that has been filled for the current cell before this function is called

Definition at line 547 of file fe_0.txt.

◆ cell

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference cell

Definition at line 547 of file fe_0.txt.

◆ compute

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not compute

Definition at line 547 of file fe_0.txt.

◆ g

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of [2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Use the version taking a [2.x.395] argument* * Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of [2.x.396] See the documentation of and with that calls the e g

Definition at line 547 of file fe_0.txt.

◆ flags

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of [2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Use the version taking a [2.x.395] argument* * Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of [2.x.396] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these flags

Definition at line 547 of file fe_0.txt.

◆ computed

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of [2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Use the version taking a [2.x.395] argument* * Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of [2.x.396] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.404] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre computed

Definition at line 547 of file fe_0.txt.

◆ Conceptually

we cannot already compute the gradients on a concrete cell at the time the current function is but we can at least pre compute the gradients on the reference and store it in the object returned An extensive discussion of the interaction between this function and FEValues can be found in the [2.x.376] documentation module See also the documentation of the InternalDataBase class [2.x.377] update_flags A set of UpdateFlags values that describe what kind of information the FEValues object requests the finite element to compute This set of flags may also include information that the finite element can not e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.384] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Like but return an object that will later be used for evaluating shape function information at quadrature points on faces of cells The object will then be used in calls to implementations of [2.x.385] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.393] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Use the version taking a [2.x.395] argument* * Like but return an object that will later be used for evaluating shape function information at quadrature points on children of faces of cells The object will then be used in calls to implementations of [2.x.396] See the documentation of and with that calls the e flags that pertain to data produced by the mapping An implementation of this function needs to set up all data fields in the returned object that are necessary to produce the finite element related data specified by these and may already pre compute part of this information as discussed above Elements may want to store these update as discussed above FEValues guarantees that this output object and the object returned by the current function will always be used together [2.x.404] A pointer to an object of a type derived from InternalDataBase and that derived classes can use to store scratch data that can be pre or for scratch arrays that then only need to be allocated once The calling site assumes ownership of this object and will delete it when it is no longer necessary* * Compute information about the shape functions on the cell denoted by the first argument Derived classes will have to implement this function based on the kind of element they represent It is called by [2.x.405] Conceptually

Definition at line 555 of file fe_0.txt.

◆ rotation

this information can either be taken from the [2.x.406] object that has been filled for the current cell before this function is or by calling the member functions of a Mapping object with the [2.x.407] object that also corresponds to the current cell The information computed by this function is used to fill the various member variables of the output argument of this function Which of the member variables of that structure should be filled is determined by the update flags stored in the [2.x.408] field of the object passed to this function These flags are typically set by [2.x.409][2.x.410] rotation

Definition at line 555 of file fe_0.txt.

◆ includes

which ones need to be filled is determined by the update flags stored inside the [2.x.453] object* * Use the version taking a [2.x.455] argument* * This function is the equivalent to [2.x.456] but for the children of faces of cells See there for an extensive discussion of its purpose It is called by [2.x.457][2.x.458] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to [2.x.459] face_no The number of the face we are currently indexed among the faces of the cell specified by the previous argument [2.x.460] sub_no The number of the i the number of the child of a that we are currently indexed among the children of the face specified by the previous argument [2.x.461] quadrature A reference to the quadrature formula in use for the current evaluation This quadrature object is the same as the one used when creating the [2.x.462] object The current object is then responsible for evaluating shape functions at the mapped locations of the quadrature points represented by this object [2.x.463] mapping A reference to the mapping object used to map from the reference cell to the current cell This object was used to compute the information in the [2.x.464] object before the current function was called It is also the mapping object that created the [2.x.465] mapping_internal object via [2.x.466] You will need the reference to this mapping object most often to call [2.x.467] to transform gradients and higher derivatives from the reference to the current cell [2.x.468] mapping_internal An object specific to the mapping object What the mapping chooses to store in there is of no relevance to the current but you may have to pass a reference to this object to certain functions of the Mapping class e::g [2.x.469] if you need to call them from the current function [2.x.470] mapping_data The output object into which the [2.x.471] function wrote the mapping information corresponding to the current cell This includes

Definition at line 555 of file fe_0.txt.

◆ function

which ones need to be filled is determined by the update flags stored inside the [2.x.453] object* * Use the version taking a [2.x.455] argument* * This function is the equivalent to [2.x.456] but for the children of faces of cells See there for an extensive discussion of its purpose It is called by [2.x.457][2.x.458] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to [2.x.459] face_no The number of the face we are currently indexed among the faces of the cell specified by the previous argument [2.x.460] sub_no The number of the i the number of the child of a that we are currently indexed among the children of the face specified by the previous argument [2.x.461] quadrature A reference to the quadrature formula in use for the current evaluation This quadrature object is the same as the one used when creating the [2.x.462] object The current object is then responsible for evaluating shape functions at the mapped locations of the quadrature points represented by this object [2.x.463] mapping A reference to the mapping object used to map from the reference cell to the current cell This object was used to compute the information in the [2.x.464] object before the current function was called It is also the mapping object that created the [2.x.465] mapping_internal object via [2.x.466] You will need the reference to this mapping object most often to call [2.x.467] to transform gradients and higher derivatives from the reference to the current cell [2.x.468] mapping_internal An object specific to the mapping object What the mapping chooses to store in there is of no relevance to the current but you may have to pass a reference to this object to certain functions of the Mapping class e::g [2.x.469] if you need to call them from the current function [2.x.470] mapping_data The output object into which the [2.x.471] function wrote the mapping information corresponding to the current cell This for Jacobians of the mapping that may be of relevance to the current function

Definition at line 555 of file fe_0.txt.

◆ words

which ones need to be filled is determined by the update flags stored inside the [2.x.430] object* FEValues ensures that this function is always called with the same pair of [2.x.432] and [2.x.433] objects In other words

Definition at line 556 of file fe_0.txt.

◆ call

which ones need to be filled is determined by the update flags stored inside the [2.x.430] object* FEValues ensures that this function is always called with the same pair of [2.x.432] and [2.x.433] objects In other if an implementation of this function knows that it has written a piece of data into the output argument in a previous call

Definition at line 556 of file fe_0.txt.

◆ considering

which ones need to be filled is determined by the update flags stored inside the [2.x.453] object* * Use the version taking a [2.x.455] argument* * This function is the equivalent to [2.x.456] but for the children of faces of cells See there for an extensive discussion of its purpose It is called by [2.x.457][2.x.458] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to [2.x.459] face_no The number of the face we are currently indexed among the faces of the cell specified by the previous argument [2.x.460] sub_no The number of the i the number of the child of a that we are currently considering

Definition at line 558 of file fe_0.txt.

◆ subface

which ones need to be filled is determined by the update flags stored inside the [2.x.453] object* * Use the version taking a [2.x.455] argument* * This function is the equivalent to [2.x.456] but for the children of faces of cells See there for an extensive discussion of its purpose It is called by [2.x.457][2.x.458] cell The cell of the triangulation for which this function is to compute a mapping from the reference cell to [2.x.459] face_no The number of the face we are currently indexed among the faces of the cell specified by the previous argument [2.x.460] sub_no The number of the subface

Definition at line 562 of file fe_0.txt.